package com.ts.api.http.platform.biz;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.gitee.apanlh.util.algorithm.encrypt.symmetric.AES;
import com.gitee.apanlh.util.base.ChooseEq;
import com.gitee.apanlh.util.base.Eq;
import com.gitee.apanlh.util.base.IteratorUtils;
import com.gitee.apanlh.util.base.MapUtils;
import com.gitee.apanlh.util.dataformat.JsonUtils;
import com.gitee.apanlh.util.valid.ValidParam;
import com.gitee.apanlh.web.model.vo.RequestVO;
import com.ts.api.http.platform.entity.apply.ApiPlatApplyDaMaiHuaHua;
import com.ts.api.http.platform.entity.dataexchange.ApiPlatDataExchangeDaMaiHuaHua;
import com.ts.api.module.api.convert.core.annotation.ApiPlan;
import com.ts.api.module.api.convert.core.annotation.ApiPlanConvertType;
import com.ts.api.module.api.convert.core.entity.ApiApplyParameter;
import com.ts.api.module.api.convert.core.entity.ApiBizStatus;
import com.ts.api.module.api.convert.core.entity.ApiDataExchangeParameter;
import com.ts.api.module.api.convert.core.utils.ApiFieldConverter;
import com.ts.api.module.api.convert.platform.entity.RespPlatformNoticeApply;
import com.ts.api.module.api.convert.platform.entity.RespPlatformPhoneMd5Apply;
import com.ts.api.module.api.convert.platform.entity.RespPlatformPhoneMd5DataExchange;
import com.ts.api.module.api.convert.platform.handler.ApiPlatformPhoneMd5ConvertHandler;
import com.ts.api.module.api.entity.ApiProtocol;
import io.micrometer.core.instrument.util.StringUtils;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 *  -安心分期（出）&大麦花花 全28
 *  链接：https://wa11o4djmo2.feishu.cn/docx/XTxmdArpJodlLzxe9DNcAVRpnHh?from=from_copylink
 *  密码：H86&8264
 *  @author 江小游
 */
@ApiPlan(productId = "183", type = ApiPlanConvertType.PLAT_PHONE_MD5)
public class ApiPlatDaMaiHuaHuaPhoneMd5Convert implements ApiPlatformPhoneMd5ConvertHandler {

    private static final String KEY = "axF7wT6Rqwerfghj";
    private static final String SOURCE = "anxfqq";

    @Override
    public Object dataExchange(ApiDataExchangeParameter apiDataChangeMessage) throws Exception {
        // 撞库流程-默认JSON发送如果需要别的方式，或者需要增加请求头，请看apiDataChangeMessage实体拓展方法
        ApiPlatDataExchangeDaMaiHuaHua apiPlatDataExchange = new ApiPlatDataExchangeDaMaiHuaHua();
        ApiFieldConverter apiFieldConverter=ApiFieldConverter.create(apiDataChangeMessage);
        // 赋值撞库属性
        // 掩码手机号
        apiPlatDataExchange.setMd5Phone(apiDataChangeMessage.getPhoneMd5());
        // ip
        if (ValidParam.isNotEmpty(apiDataChangeMessage.getIp())) {
            apiPlatDataExchange.setIpaddress(apiDataChangeMessage.getIp());
        } else {
            apiPlatDataExchange.setIpaddress("127.0.0.1");
        }
        // 城市
        apiPlatDataExchange.setCity(apiDataChangeMessage.getCity().replace("市", "").replace("地区", ""));
        // 省
        apiPlatDataExchange.setProvince(apiDataChangeMessage.getProvinceName().replace("自治区", "").replace("省", ""));
        // 姓名
        apiPlatDataExchange.setName("浩安星");
        // 年龄
        apiPlatDataExchange.setAge(apiFieldConverter.getAgeInt());
        //  撞库字段映射
        dataExchangeFieldMapping(apiDataChangeMessage, apiPlatDataExchange);
        AES aes=AES.createEcb(KEY.getBytes());
        String json = JsonUtils.toJson(apiPlatDataExchange);
        String data=aes.encryptToBase64Str(json);
        Map<String,Object> map= MapUtils.newHashMap(newMap -> {
            newMap.put("source", SOURCE);
            newMap.put("data", data);
        });
        //  请求实体转换,默认JSON方式，如果FORM方式直接返回实体类，并且设置请求头为FORM表单
        return JsonUtils.toJson(map);
    }

    @Override
    public RespPlatformPhoneMd5DataExchange respDataExchange(String respJson) throws Exception {
        // 撞库返回响应体判断
        JSONObject jsonObject = JsonUtils.get(respJson);
        if (jsonObject == null) {
            return RespPlatformPhoneMd5DataExchange.ofFail();
        }
        // 根据文档响应判断
        if (!Eq.object(jsonObject.getInteger("code"), 200)) {
            return RespPlatformPhoneMd5DataExchange.ofFail();
        }
        JSONObject resData = JsonUtils.get(respJson).getJSONObject("data");
        if (!resData.getBoolean("status")){
            return RespPlatformPhoneMd5DataExchange.ofFail();
        }
        BigDecimal price = resData.getBigDecimal("price");
        String productName = resData.getString("productName");
        String companyName = resData.getString("companyName");
        String logo =  resData.getString("productLogo");
        // 用户协议
        List<ApiProtocol> protocolList = new ArrayList<>();
        // 获取协议
        JSONArray listProtocolResult = resData.getJSONArray("agreementList");
        IteratorUtils.array(listProtocolResult, (item, index) -> {
            JSONObject protocolObject = listProtocolResult.getJSONObject(index);
            ApiProtocol protocol = new ApiProtocol();
            protocol.setProtocolName(protocolObject.getString("title"));
            protocol.setProtocolUrl(protocolObject.getString("url"));
            protocolList.add(protocol);
        });
        RespPlatformPhoneMd5DataExchange result = RespPlatformPhoneMd5DataExchange.ofSuc();

        result.setPrice(price);
        result.setDisplayName(companyName);
        result.setProductName(productName);
        result.setLogoPath(logo);
        result.setProtocolList(protocolList);
        return result;
    }

    @Override
    public Object apply(ApiApplyParameter apiApplyMessage) throws Exception {
        // 进件流程-默认JSON发送如果需要别的方式，或者需要增加请求头，请看apiApplyMessage拓展方法
        ApiPlatApplyDaMaiHuaHua apiPlatApply = new ApiPlatApplyDaMaiHuaHua();
        ApiFieldConverter apiFieldConverter=ApiFieldConverter.create(apiApplyMessage);
        // 赋值进件属性
        apiPlatApply.setName(apiApplyMessage.getUserName());
        // 撞库id
        apiPlatApply.setTid(apiApplyMessage.dataExchangeApplyId());
        // 电话
        apiPlatApply.setPhone(apiApplyMessage.getPhone());
        // 用户ip
        if (ValidParam.isNotEmpty(apiApplyMessage.getIp())) {
            apiPlatApply.setIpaddress(apiApplyMessage.getIp());
        } else {
            apiPlatApply.setIpaddress("127.0.0.1");
        }
        // 城市
        apiPlatApply.setCity(apiApplyMessage.getCity().replace("市", "").replace("地区", ""));
        // 省
        apiPlatApply.setProvince(apiApplyMessage.getProvinceName().replace("自治区", "").replace("省", ""));
        // 年龄
        apiPlatApply.setAge(apiFieldConverter.getAgeInt());
        // 进件字段映射
        applyFieldMapping(apiApplyMessage, apiPlatApply);

        // 请求实体转换,默认JSON方式，如果FORM方式直接返回实体类，并且设置请求头为FORM表单
        AES aes=AES.createEcb(KEY.getBytes());
        String data=aes.encryptToBase64Str(JsonUtils.toJson(apiPlatApply));
        Map<String,Object> map= MapUtils.newHashMap(newMap -> {
            newMap.put("source", SOURCE);
            newMap.put("data", data);
        });
        // 请求实体转换,默认JSON方式，如果FORM方式直接返回实体类，并且设置请求头为FORM表单
        return JsonUtils.toJson(map);
    }

    @Override
    public RespPlatformPhoneMd5Apply respApply(String respJson) throws Exception {
        // 进件返回响应体判断
        JSONObject jsonObject = JsonUtils.get(respJson);
        if (jsonObject == null) {
            return RespPlatformPhoneMd5Apply.ofFail();
        }
        if (!Eq.object(jsonObject.getInteger("code"), 200)) {
            return RespPlatformPhoneMd5Apply.ofFail();
        }
        JSONObject data = jsonObject.getJSONObject("data");
        String url = data.getString("url");
        RespPlatformPhoneMd5Apply respPlatformPhoneMd5Apply = RespPlatformPhoneMd5Apply.ofSuc();
        respPlatformPhoneMd5Apply.setCallUrl(url);
        return respPlatformPhoneMd5Apply;
    }

    /**
     *   撞库字段转换映射
     *   1.撞库字段转换(不需要的自行删除)
     *   2.第一个形参值是我方值, 第二个形参值,是对方文档值,必须注意参数类型对应, end指的是如果都不存在给默认值)
     */
    private void dataExchangeFieldMapping(ApiDataExchangeParameter apiDataChangeMessage, ApiPlatDataExchangeDaMaiHuaHua apiPlatDataExchange) {
          // 性别 0 ：女；1 ：男
        Integer sex = ChooseEq.create(apiDataChangeMessage.getSex())
                .when("0", 1)
                .when("1", 0)
                .end(0);
        apiPlatDataExchange.setSex(sex);
        // 贷款金额 1:2w；2:3w；3:5w；4:10w；5:20w；6:50w；7:100w；8:100w 以上；9:1w 以下
        Integer loanAmount = ChooseEq.create(apiDataChangeMessage.getLoanAmount())
                .when("1", 2)
                .when("2", 4)
                .when("3", 4)
                .when("4", 6)
                .end(1);
        apiPlatDataExchange.setLoan(loanAmount);
        // 贷款期限 1：2 年以上 2：1-2 年 3：6-12 个月 4：3-6 个月 5：1-3 个月
        Integer loan = ChooseEq.create(apiDataChangeMessage.getLoanTerm())
                .when("1", 5)
                .when("2", 4)
                .when("3", 3)
                .when("4", 2)
                .when("5", 1)
                .when("6", 1)
                .end(5);
        apiPlatDataExchange.setLoan_term(loan);
        // 贷款用途 1 ：购房 2 ：购车 3 ：住房装修 4 ：教育深造 5 ：休闲旅游 6 ：个人消费 7 ：房租缴纳 8 ：其他贷款
        Integer loanPurpose = ChooseEq.create(apiDataChangeMessage.getLoanPurpose())
                .when("1", 5)
                .when("2", 4)
                .when("3", 8)
                .when("4", 3)
                .when("5", 8)
                .when("6", 6)
                .end(8);
        apiPlatDataExchange.setLoan_use(loanPurpose);
        // 职业身份 1 ：上班族 2 ：企业主 3：  自由职业者
        Integer career = ChooseEq.create(apiDataChangeMessage.getCareer())
                .when("1", 1)
                .when("2", 3)
                .when("3", 2)
                .when("4", 1)
                .when("5", 1)
                .end(2);
        apiPlatDataExchange.setProfessional(career);
        // 单位类型 0 ：无 1 ：私营企业 2：  国企单位  3 ：事业单位
        Integer jobType = ChooseEq.create(apiDataChangeMessage.getCareer())
                .when("1", 0)
                .when("2", 1)
                .when("3", 0)
                .when("4", 2)
                .when("5", 1)
                .end(0);
        apiPlatDataExchange.setEnterprise_type(jobType);
        /*
           月收入 0：无
           1 ：4000 以下
           2 ：4000-8000
           3 ：8000-1.5 万
           4：  1.5 万-2 万
           5：  2 万-3 万
           6：  3 万以上
         */
        Integer monthlySalary = ChooseEq.create(apiDataChangeMessage.getMonthlySalary())
                .when("1", 1)
                .when("2", 2)
                .when("3", 3)
                .when("4", 5)
                .when("5", 6)
                .end(1);
        apiPlatDataExchange.setMonthly_income(monthlySalary);
        // 社保公积金 1 ：都有 2 ：仅社保 3 ：仅公积金 4 ：都没有
        String socialSecurity = apiDataChangeMessage.getSocialSecurity();
        String providentFund = apiDataChangeMessage.getProvidentFund();
        if (StringUtils.isNotBlank(socialSecurity) && StringUtils.isNotBlank(providentFund) && !"1".equals(socialSecurity) && !"1".equals(providentFund)){
            apiPlatDataExchange.setSocial_security_and_accumulation_fund(1);
        }else if ("1".equals(socialSecurity) && !"1".equals(providentFund)){
            apiPlatDataExchange.setSocial_security_and_accumulation_fund(2);
        }else if (!"1".equals(socialSecurity) && "1".equals(providentFund)){
            apiPlatDataExchange.setSocial_security_and_accumulation_fund(3);
        }else {
            apiPlatDataExchange.setSocial_security_and_accumulation_fund(4);
        }
       /*
          我方字典-工资发放形式/银行代发/打卡方式
          1.银行代发打卡
          2.现金收入
          3.个人转账
          如果对方只需要"银行代发-有/无"使用:apiFieldConverter.hasSalaryBankToStr
          如果对方只需要"银行代发-是/否"使用:apiFieldConverter.hasSalaryBankChooseToStr
          如果对方只需要"银行代发-0/1"使用:apiFieldConverter.hasSalaryBankToNumber
        */
        Integer salaryPayMethod = ChooseEq.create(apiDataChangeMessage.getSalaryPayMethod())
                .when("1", 1)
                .when("2", 3)
                .when("3", 2)
                .end(2);
        apiPlatDataExchange.setSalary_type(salaryPayMethod);
        // 企业流水0 ：无；1：  5 万以下；2：  5-30 万；3：  30 万-100 万；4：  100 万-1000 万；5：  1000 万以上
        Integer bizPubAccBankDetails = ChooseEq.create(apiDataChangeMessage.getBizPubAccBankDetails())
                .when("1", 0)
                .when("2", 3)
                .when("3", 4)
                .end();
        apiPlatDataExchange.setEnterprise_flow(bizPubAccBankDetails);
       /*
          营业执照注册年限
          1.未注册
          2.注册1年以下
          3.注册1~5年
          4.注册5年以上
       */
        Integer bizLicenseYear = ChooseEq.create(apiDataChangeMessage.getBizLicenseYear())
                .when("1", 0)
                .when("2", 2)
                .when("3", 3)
                .when("4", 4)
                .end(0);
        apiPlatDataExchange.setEnterprise_license(bizLicenseYear);
        /*
          我方字典-学历
          1.初中及以下
          2.中专
          3.高中
          4.大专
          5.本科
          6.研究生及以上
        */
        Integer educationAttainment = ChooseEq.create(apiDataChangeMessage.getEducationAttainment())
                .when("1", 1)
                .when("2", 2)
                .when("3", 2)
                .when("4", 3)
                .when("5", 4)
                .when("6", 5)
                .end(1);
        apiPlatDataExchange.setEducation(educationAttainment);
        /*
           我方字典-信用情况（逾期）
           1.无逾期
           2.当前有逾期
           3.一年以内无逾期
           如果对方文档是需要返回"0"和"1" 使用:apiFieldConverter.hasOverdueToNumber
           如果对方文档是需要返回"有"和"无",使用:apiFieldConverter.hasOverdueToStr方法
         */
        Integer overdue = ChooseEq.create(apiDataChangeMessage.getOverdue())
                .when("1", 1)
                .when("2", 4)
                .when("3", 1)
                .end(1);
        apiPlatDataExchange.setCredit_history(overdue);
        /*
           我方字典-芝麻分
           1.600分以下
           2.600~649分
           3.650~699分
           4.700分以上
           如果对方需要"分值形式"如:650，700,使用apiFieldConverter.getSesameCreditNumber/getSesameCreditStr
           如果对方要"文字形式"如:600分以下,600~649分,使用apiFieldConverter.getSesameCreditText
         */
        Integer sesameCredit = ChooseEq.create(apiDataChangeMessage.getSesameCredit())
                .when("1", 5)
                .when("2", 1)
                .when("3", 2)
                .when("4", 3)
                .end(1);
        apiPlatDataExchange.setZhima_credit(sesameCredit);
        /*
          我方字典-房产情况
          1.无房产
          2.有房不抵押
          3.有房可抵押
          4.有房产
          5.有按揭房产
          6.有全款房产
          如果对方需要"有无月收入"如:有/无，使用使用apiFieldConverter.hasRealEstateInfoToStr
          如果对方需要"有无月收入"如:0/1，使用使用apiFieldConverter.hasRealEstateInfoToNumber
        */
        Integer realEstateInfo = ChooseEq.create(apiDataChangeMessage.getRealEstateInfo())
                .when("1", 4)
                .when("2", 1)
                .when("3", 1)
                .when("4", 1)
                .when("5", 1)
                .when("6", 1)
                .end(1);
        apiPlatDataExchange.setHouse_property(realEstateInfo);
        /*
           我方字典-车辆情况
           1.无车产
           2.有车不抵押
           3.有车可抵押
           4.有车
           如果对方文档是需要返回"0"和"1" 使用:apiFieldConverter.hasCarInfoToNumber
           如果对方文档是需要返回"有"和"无",使用:apiFieldConverter.hasCarInfoToStr
         */
        Integer carInfo = ChooseEq.create(apiDataChangeMessage.getCarInfo())
                .when("1", 3)
                .when("2", 1)
                .when("3", 2)
                .when("4", 1)
                .end(1);
        apiPlatDataExchange.setCar_property(carInfo);
        // 微粒贷 1 ：有；2 ：无
        apiPlatDataExchange.setMicro_loan(2);
        // 寿险 1 ：有；2 ：无
        Integer insurancePolicy = ChooseEq.create(apiDataChangeMessage.getInsurancePolicy())
                .when("1", 2)
                .when("2", 1)
                .when("3", 1)
                .when("4", 1)
                .end(2);
        apiPlatDataExchange.setLife_insurance(insurancePolicy);

    }

    /**
     *   字段转换映射
     *   1.表单信息字段转换(不需要的自行删除)
     *   2.第一个形参值是我方值, 第二个形参值,是对方文档值,必须注意参数类型对应, end指的是如果都不存在给默认值)
     */
    private void applyFieldMapping(ApiApplyParameter apiApplyMessage, ApiPlatApplyDaMaiHuaHua apiPlatApply) {
        // 性别-要获取中文性别（男/女）使用apiFieldConverter.getSexText
        Integer sex = ChooseEq.create(apiApplyMessage.getSex())
                .when("0", 1)
                .when("1", 0)
                .end(0);
        apiPlatApply.setSex(sex);
        /*
           我方字典-贷款金额
           1.3万以下
           2.5万-10万
           3.10万-20万
           4.20万以上
           如果对方文档需要"带单位"如:3万，5万,使用apiFieldConverter.getLoanAmountUnit
           如果对方文档需要"数字形式"使用apiFieldConverter.getLoanAmountInt(),返回30000，50000
         */
        Integer loanAmount = ChooseEq.create(apiApplyMessage.getLoanAmount())
                .when("1", 2)
                .when("2", 4)
                .when("3", 4)
                .when("4", 6)
                .end(1);
        apiPlatApply.setLoan(loanAmount);
        // 贷款期限 1：2 年以上 2：1-2 年 3：6-12 个月 4：3-6 个月 5：1-3 个月"
        Integer loan = ChooseEq.create(apiApplyMessage.getLoanTerm())
                .when("1", 5)
                .when("2", 4)
                .when("3", 3)
                .when("4", 2)
                .when("5", 1)
                .when("6", 1)
                .end(5);
        apiPlatApply.setLoan_term(loan);
        // 贷款用途"1 ：购房 2 ：购车
        // 3 ：住房装修
        // 4 ：教育深造
        // 5 ：休闲旅游
        // 6 ：个人消费
        // 7 ：房租缴纳
        // 8 ：其他贷款"
        Integer loanPurpose = ChooseEq.create(apiApplyMessage.getLoanPurpose())
                .when("1", 5)
                .when("2", 4)
                .when("3", 8)
                .when("4", 3)
                .when("5", 8)
                .when("6", 6)
                .end(8);
        apiPlatApply.setLoan_use(loanPurpose);
        /*
           我方字典-职业
           1.上班族
           2.自由职业
           3.企业主（有营业执照）
           4.公务员或事业单位
           如果对方需要"文字形式"如:上班族/公务员或事业单位,使用apiFieldConverter.getCareerText
           如果对方需要"有无职业或者是否有工作"如:有/无，使用使用apiFieldConverter.hasCareerToStr
           如果对方需要"有无职业或者是否有工作"如:0/1，使用使用apiFieldConverter.hasCareerToNumber
        */
        Integer career = ChooseEq.create(apiApplyMessage.getCareer())
                .when("1", 1)
                .when("2", 3)
                .when("3", 2)
                .when("4", 1)
                .when("5", 1)
                .end(2);
        apiPlatApply.setProfessional(career);
        // 单位类型 0 ：无 1 ：私营企业 2：  国企单位  3 ：事业单位
        Integer jobType = ChooseEq.create(apiApplyMessage.getCareer())
                .when("1", 0)
                .when("2", 1)
                .when("3", 0)
                .when("4", 2)
                .when("5", 1)
                .end(0);
        apiPlatApply.setEnterprise_type(jobType);
        /*
          我方字典-月收入
          1.1000-3000
          2.3000-8000
          3.8000~15000
          4.15000~30000
          5.30000以上
          如果对方需要"数值形式"如:3000,5000,使用apiFieldConverter.getMonthlySalaryNumber
          如果对方需要"有无月收入"如:有/无，使用使用apiFieldConverter.hasMonthlySalaryToStr
          如果对方需要"有无月收入"如:0/1，使用使用apiFieldConverter.hasMonthlySalaryToNumber
        */
        Integer monthlySalary = ChooseEq.create(apiApplyMessage.getMonthlySalary())
                .when("1", 1)
                .when("2", 2)
                .when("3", 3)
                .when("4", 5)
                .when("5", 6)
                .end(1);
        apiPlatApply.setMonthly_income(monthlySalary);
        // 社保公积金 1 ：都有 2 ：仅社保 3 ：仅公积金 4 ：都没有
        String socialSecurity = apiApplyMessage.getSocialSecurity();
        String providentFund = apiApplyMessage.getProvidentFund();
        if (StringUtils.isNotBlank(socialSecurity) && StringUtils.isNotBlank(providentFund) && !"1".equals(socialSecurity) && !"1".equals(providentFund)){
            apiPlatApply.setSocial_security_and_accumulation_fund(1);
        }else if ("1".equals(socialSecurity) && !"1".equals(providentFund)){
            apiPlatApply.setSocial_security_and_accumulation_fund(2);
        }else if (!"1".equals(socialSecurity) && "1".equals(providentFund)){
            apiPlatApply.setSocial_security_and_accumulation_fund(3);
        }else {
            apiPlatApply.setSocial_security_and_accumulation_fund(4);
        }
       /*
          我方字典-工资发放形式/银行代发/打卡方式
          1.银行代发打卡
          2.现金收入
          3.个人转账
          如果对方只需要"银行代发-有/无"使用:apiFieldConverter.hasSalaryBankToStr
          如果对方只需要"银行代发-是/否"使用:apiFieldConverter.hasSalaryBankChooseToStr
          如果对方只需要"银行代发-0/1"使用:apiFieldConverter.hasSalaryBankToNumber
        */
        Integer salaryPayMethod = ChooseEq.create(apiApplyMessage.getSalaryPayMethod())
                .when("1", 1)
                .when("2", 3)
                .when("3", 2)
                .end(2);
        apiPlatApply.setSalary_type(salaryPayMethod);

        Integer bizPubAccBankDetails = ChooseEq.create(apiApplyMessage.getBizPubAccBankDetails())
                .when("1", 0)
                .when("2", 3)
                .when("3", 4)
                .end(0);
        apiPlatApply.setEnterprise_flow(bizPubAccBankDetails);
       /*
          营业执照注册年限
          1.未注册
          2.注册1年以下
          3.注册1~5年
          4.注册5年以上
       */
        Integer bizLicenseYear = ChooseEq.create(apiApplyMessage.getBizLicenseYear())
                .when("1", 0)
                .when("2", 2)
                .when("3", 3)
                .when("4", 4)
                .end(0);
        apiPlatApply.setEnterprise_license(bizLicenseYear);
        /*
          我方字典-学历
          1.初中及以下
          2.中专
          3.高中
          4.大专
          5.本科
          6.研究生及以上
        */
        Integer educationAttainment = ChooseEq.create(apiApplyMessage.getEducationAttainment())
                .when("1", 1)
                .when("2", 2)
                .when("3", 2)
                .when("4", 3)
                .when("5", 4)
                .when("6", 5)
                .end(1);
        apiPlatApply.setEducation(educationAttainment);
        /*
           我方字典-信用情况（逾期）
           1.无逾期
           2.当前有逾期
           3.一年以内无逾期
           如果对方文档是需要返回"0"和"1" 使用:apiFieldConverter.hasOverdueToNumber
           如果对方文档是需要返回"有"和"无",使用:apiFieldConverter.hasOverdueToStr方法
         */
        Integer overdue = ChooseEq.create(apiApplyMessage.getOverdue())
                .when("1", 1)
                .when("2", 4)
                .when("3", 1)
                .end(1);
        apiPlatApply.setCredit_history(overdue);
        /*
           我方字典-芝麻分
           1.600分以下
           2.600~649分
           3.650~699分
           4.700分以上
           如果对方需要"分值形式"如:650，700,使用apiFieldConverter.getSesameCreditNumber/getSesameCreditStr
           如果对方要"文字形式"如:600分以下,600~649分,使用apiFieldConverter.getSesameCreditText
         */
        Integer sesameCredit = ChooseEq.create(apiApplyMessage.getSesameCredit())
                .when("1", 5)
                .when("2", 1)
                .when("3", 2)
                .when("4", 3)
                .end(1);
        apiPlatApply.setZhima_credit(sesameCredit);
        /*
          我方字典-房产情况
          1.无房产
          2.有房不抵押
          3.有房可抵押
          4.有房产
          5.有按揭房产
          6.有全款房产
          如果对方需要"有无月收入"如:有/无，使用使用apiFieldConverter.hasRealEstateInfoToStr
          如果对方需要"有无月收入"如:0/1，使用使用apiFieldConverter.hasRealEstateInfoToNumber
        */
        Integer realEstateInfo = ChooseEq.create(apiApplyMessage.getRealEstateInfo())
                .when("1", 4)
                .when("2", 1)
                .when("3", 1)
                .when("4", 1)
                .when("5", 1)
                .when("6", 1)
                .end(1);
        apiPlatApply.setHouse_property(realEstateInfo);
        /*
           我方字典-车辆情况
           1.无车产
           2.有车不抵押
           3.有车可抵押
           4.有车
           如果对方文档是需要返回"0"和"1" 使用:apiFieldConverter.hasCarInfoToNumber
           如果对方文档是需要返回"有"和"无",使用:apiFieldConverter.hasCarInfoToStr
         */
        Integer carInfo = ChooseEq.create(apiApplyMessage.getCarInfo())
                .when("1", 3)
                .when("2", 1)
                .when("3", 2)
                .when("4", 1)
                .end(1);
        apiPlatApply.setCar_property(carInfo);

        apiPlatApply.setMicro_loan(2);
        Integer insurancePolicy = ChooseEq.create(apiApplyMessage.getInsurancePolicy())
                .when("1", 2)
                .when("2", 1)
                .when("3", 1)
                .when("4", 1)
                .end(2);
        apiPlatApply.setLife_insurance(insurancePolicy);
    }

    @Override
    public RespPlatformNoticeApply parseApplyNotice(RequestVO requestVO) {
        return null;
    }

    @Override
    public Map<String, Object> respApplyNotice(ApiBizStatus apiBizStatus) {
        return Map.of();
    }
}
